home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / iffparse_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  24KB  |  805 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_IFFPARSE_H
  4. #define _PPCPRAGMA_IFFPARSE_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__IFFPARSE_H
  7. #include <powerup/ppcinline/iffparse.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef IFFPARSE_BASE_NAME
  24. #define IFFPARSE_BASE_NAME IFFParseBase
  25. #endif /* !IFFPARSE_BASE_NAME */
  26.  
  27. #define    AllocIFF()    _AllocIFF(IFFPARSE_BASE_NAME)
  28.  
  29. static __inline struct IFFHandle *
  30. _AllocIFF(void *IFFParseBase)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.caos_Un.Offset    =    (-30);
  40.     MyCaos.a6        =(ULONG) IFFParseBase;    
  41.     return((struct IFFHandle *)PPCCallOS(&MyCaos));
  42. }
  43.  
  44. #define    AllocLocalItem(type, id, ident, dataSize)    _AllocLocalItem(IFFPARSE_BASE_NAME, type, id, ident, dataSize)
  45.  
  46. static __inline struct LocalContextItem *
  47. _AllocLocalItem(void *IFFParseBase, long type, long id, long ident, long dataSize)
  48. {
  49. struct Caos    MyCaos;
  50.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  51. //    MyCaos.M68kStart    =    NULL;
  52. //    MyCaos.M68kSize        =    0;
  53.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  54. //    MyCaos.PPCStart        =    NULL;
  55. //    MyCaos.PPCSize        =    0;
  56.     MyCaos.d0        =(ULONG) type;
  57.     MyCaos.d1        =(ULONG) id;
  58.     MyCaos.d2        =(ULONG) ident;
  59.     MyCaos.d3        =(ULONG) dataSize;
  60.     MyCaos.caos_Un.Offset    =    (-186);
  61.     MyCaos.a6        =(ULONG) IFFParseBase;    
  62.     return((struct LocalContextItem *)PPCCallOS(&MyCaos));
  63. }
  64.  
  65. #define    CloseClipboard(clipHandle)    _CloseClipboard(IFFPARSE_BASE_NAME, clipHandle)
  66.  
  67. static __inline void
  68. _CloseClipboard(void *IFFParseBase, struct ClipboardHandle *clipHandle)
  69. {
  70. struct Caos    MyCaos;
  71.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  72. //    MyCaos.M68kStart    =    NULL;
  73. //    MyCaos.M68kSize        =    0;
  74.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  75. //    MyCaos.PPCStart        =    NULL;
  76. //    MyCaos.PPCSize        =    0;
  77.     MyCaos.a0        =(ULONG) clipHandle;
  78.     MyCaos.caos_Un.Offset    =    (-252);
  79.     MyCaos.a6        =(ULONG) IFFParseBase;    
  80.     PPCCallOS(&MyCaos);
  81. }
  82.  
  83. #define    CloseIFF(iff)    _CloseIFF(IFFPARSE_BASE_NAME, iff)
  84.  
  85. static __inline void
  86. _CloseIFF(void *IFFParseBase, struct IFFHandle *iff)
  87. {
  88. struct Caos    MyCaos;
  89.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  90. //    MyCaos.M68kStart    =    NULL;
  91. //    MyCaos.M68kSize        =    0;
  92.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  93. //    MyCaos.PPCStart        =    NULL;
  94. //    MyCaos.PPCSize        =    0;
  95.     MyCaos.a0        =(ULONG) iff;
  96.     MyCaos.caos_Un.Offset    =    (-48);
  97.     MyCaos.a6        =(ULONG) IFFParseBase;    
  98.     PPCCallOS(&MyCaos);
  99. }
  100.  
  101. #define    CollectionChunk(iff, type, id)    _CollectionChunk(IFFPARSE_BASE_NAME, iff, type, id)
  102.  
  103. static __inline LONG
  104. _CollectionChunk(void *IFFParseBase, struct IFFHandle *iff, long type, long id)
  105. {
  106. struct Caos    MyCaos;
  107.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  108. //    MyCaos.M68kStart    =    NULL;
  109. //    MyCaos.M68kSize        =    0;
  110.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  111. //    MyCaos.PPCStart        =    NULL;
  112. //    MyCaos.PPCSize        =    0;
  113.     MyCaos.a0        =(ULONG) iff;
  114.     MyCaos.d0        =(ULONG) type;
  115.     MyCaos.d1        =(ULONG) id;
  116.     MyCaos.caos_Un.Offset    =    (-138);
  117.     MyCaos.a6        =(ULONG) IFFParseBase;    
  118.     return((LONG)PPCCallOS(&MyCaos));
  119. }
  120.  
  121. #define    CollectionChunks(iff, propArray, numPairs)    _CollectionChunks(IFFPARSE_BASE_NAME, iff, propArray, numPairs)
  122.  
  123. static __inline LONG
  124. _CollectionChunks(void *IFFParseBase, struct IFFHandle *iff, LONG *propArray, long numPairs)
  125. {
  126. struct Caos    MyCaos;
  127.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  128. //    MyCaos.M68kStart    =    NULL;
  129. //    MyCaos.M68kSize        =    0;
  130.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  131. //    MyCaos.PPCStart        =    NULL;
  132. //    MyCaos.PPCSize        =    0;
  133.     MyCaos.a0        =(ULONG) iff;
  134.     MyCaos.a1        =(ULONG) propArray;
  135.     MyCaos.d0        =(ULONG) numPairs;
  136.     MyCaos.caos_Un.Offset    =    (-144);
  137.     MyCaos.a6        =(ULONG) IFFParseBase;    
  138.     return((LONG)PPCCallOS(&MyCaos));
  139. }
  140.  
  141. #define    CurrentChunk(iff)    _CurrentChunk(IFFPARSE_BASE_NAME, iff)
  142.  
  143. static __inline struct ContextNode *
  144. _CurrentChunk(void *IFFParseBase, struct IFFHandle *iff)
  145. {
  146. struct Caos    MyCaos;
  147.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  148. //    MyCaos.M68kStart    =    NULL;
  149. //    MyCaos.M68kSize        =    0;
  150.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  151. //    MyCaos.PPCStart        =    NULL;
  152. //    MyCaos.PPCSize        =    0;
  153.     MyCaos.a0        =(ULONG) iff;
  154.     MyCaos.caos_Un.Offset    =    (-174);
  155.     MyCaos.a6        =(ULONG) IFFParseBase;    
  156.     return((struct ContextNode *)PPCCallOS(&MyCaos));
  157. }
  158.  
  159. #define    EntryHandler(iff, type, id, position, handler, object)    _EntryHandler(IFFPARSE_BASE_NAME, iff, type, id, position, handler, object)
  160.  
  161. static __inline LONG
  162. _EntryHandler(void *IFFParseBase, struct IFFHandle *iff, long type, long id, long position, struct Hook *handler, APTR object)
  163. {
  164. struct Caos    MyCaos;
  165.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  166. //    MyCaos.M68kStart    =    NULL;
  167. //    MyCaos.M68kSize        =    0;
  168.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  169. //    MyCaos.PPCStart        =    NULL;
  170. //    MyCaos.PPCSize        =    0;
  171.     MyCaos.a0        =(ULONG) iff;
  172.     MyCaos.d0        =(ULONG) type;
  173.     MyCaos.d1        =(ULONG) id;
  174.     MyCaos.d2        =(ULONG) position;
  175.     MyCaos.a1        =(ULONG) handler;
  176.     MyCaos.a2        =(ULONG) object;
  177.     MyCaos.caos_Un.Offset    =    (-102);
  178.     MyCaos.a6        =(ULONG) IFFParseBase;    
  179.     return((LONG)PPCCallOS(&MyCaos));
  180. }
  181.  
  182. #define    ExitHandler(iff, type, id, position, handler, object)    _ExitHandler(IFFPARSE_BASE_NAME, iff, type, id, position, handler, object)
  183.  
  184. static __inline LONG
  185. _ExitHandler(void *IFFParseBase, struct IFFHandle *iff, long type, long id, long position, struct Hook *handler, APTR object)
  186. {
  187. struct Caos    MyCaos;
  188.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  189. //    MyCaos.M68kStart    =    NULL;
  190. //    MyCaos.M68kSize        =    0;
  191.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  192. //    MyCaos.PPCStart        =    NULL;
  193. //    MyCaos.PPCSize        =    0;
  194.     MyCaos.a0        =(ULONG) iff;
  195.     MyCaos.d0        =(ULONG) type;
  196.     MyCaos.d1        =(ULONG) id;
  197.     MyCaos.d2        =(ULONG) position;
  198.     MyCaos.a1        =(ULONG) handler;
  199.     MyCaos.a2        =(ULONG) object;
  200.     MyCaos.caos_Un.Offset    =    (-108);
  201.     MyCaos.a6        =(ULONG) IFFParseBase;    
  202.     return((LONG)PPCCallOS(&MyCaos));
  203. }
  204.  
  205. #define    FindCollection(iff, type, id)    _FindCollection(IFFPARSE_BASE_NAME, iff, type, id)
  206.  
  207. static __inline struct CollectionItem *
  208. _FindCollection(void *IFFParseBase, struct IFFHandle *iff, long type, long id)
  209. {
  210. struct Caos    MyCaos;
  211.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  212. //    MyCaos.M68kStart    =    NULL;
  213. //    MyCaos.M68kSize        =    0;
  214.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  215. //    MyCaos.PPCStart        =    NULL;
  216. //    MyCaos.PPCSize        =    0;
  217.     MyCaos.a0        =(ULONG) iff;
  218.     MyCaos.d0        =(ULONG) type;
  219.     MyCaos.d1        =(ULONG) id;
  220.     MyCaos.caos_Un.Offset    =    (-162);
  221.     MyCaos.a6        =(ULONG) IFFParseBase;    
  222.     return((struct CollectionItem *)PPCCallOS(&MyCaos));
  223. }
  224.  
  225. #define    FindLocalItem(iff, type, id, ident)    _FindLocalItem(IFFPARSE_BASE_NAME, iff, type, id, ident)
  226.  
  227. static __inline struct LocalContextItem *
  228. _FindLocalItem(void *IFFParseBase, struct IFFHandle *iff, long type, long id, long ident)
  229. {
  230. struct Caos    MyCaos;
  231.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  232. //    MyCaos.M68kStart    =    NULL;
  233. //    MyCaos.M68kSize        =    0;
  234.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  235. //    MyCaos.PPCStart        =    NULL;
  236. //    MyCaos.PPCSize        =    0;
  237.     MyCaos.a0        =(ULONG) iff;
  238.     MyCaos.d0        =(ULONG) type;
  239.     MyCaos.d1        =(ULONG) id;
  240.     MyCaos.d2        =(ULONG) ident;
  241.     MyCaos.caos_Un.Offset    =    (-210);
  242.     MyCaos.a6        =(ULONG) IFFParseBase;    
  243.     return((struct LocalContextItem *)PPCCallOS(&MyCaos));
  244. }
  245.  
  246. #define    FindProp(iff, type, id)    _FindProp(IFFPARSE_BASE_NAME, iff, type, id)
  247.  
  248. static __inline struct StoredProperty *
  249. _FindProp(void *IFFParseBase, struct IFFHandle *iff, long type, long id)
  250. {
  251. struct Caos    MyCaos;
  252.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  253. //    MyCaos.M68kStart    =    NULL;
  254. //    MyCaos.M68kSize        =    0;
  255.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  256. //    MyCaos.PPCStart        =    NULL;
  257. //    MyCaos.PPCSize        =    0;
  258.     MyCaos.a0        =(ULONG) iff;
  259.     MyCaos.d0        =(ULONG) type;
  260.     MyCaos.d1        =(ULONG) id;
  261.     MyCaos.caos_Un.Offset    =    (-156);
  262.     MyCaos.a6        =(ULONG) IFFParseBase;    
  263.     return((struct StoredProperty *)PPCCallOS(&MyCaos));
  264. }
  265.  
  266. #define    FindPropContext(iff)    _FindPropContext(IFFPARSE_BASE_NAME, iff)
  267.  
  268. static __inline struct ContextNode *
  269. _FindPropContext(void *IFFParseBase, struct IFFHandle *iff)
  270. {
  271. struct Caos    MyCaos;
  272.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  273. //    MyCaos.M68kStart    =    NULL;
  274. //    MyCaos.M68kSize        =    0;
  275.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  276. //    MyCaos.PPCStart        =    NULL;
  277. //    MyCaos.PPCSize        =    0;
  278.     MyCaos.a0        =(ULONG) iff;
  279.     MyCaos.caos_Un.Offset    =    (-168);
  280.     MyCaos.a6        =(ULONG) IFFParseBase;    
  281.     return((struct ContextNode *)PPCCallOS(&MyCaos));
  282. }
  283.  
  284. #define    FreeIFF(iff)    _FreeIFF(IFFPARSE_BASE_NAME, iff)
  285.  
  286. static __inline void
  287. _FreeIFF(void *IFFParseBase, struct IFFHandle *iff)
  288. {
  289. struct Caos    MyCaos;
  290.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  291. //    MyCaos.M68kStart    =    NULL;
  292. //    MyCaos.M68kSize        =    0;
  293.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  294. //    MyCaos.PPCStart        =    NULL;
  295. //    MyCaos.PPCSize        =    0;
  296.     MyCaos.a0        =(ULONG) iff;
  297.     MyCaos.caos_Un.Offset    =    (-54);
  298.     MyCaos.a6        =(ULONG) IFFParseBase;    
  299.     PPCCallOS(&MyCaos);
  300. }
  301.  
  302. #define    FreeLocalItem(localItem)    _FreeLocalItem(IFFPARSE_BASE_NAME, localItem)
  303.  
  304. static __inline void
  305. _FreeLocalItem(void *IFFParseBase, struct LocalContextItem *localItem)
  306. {
  307. struct Caos    MyCaos;
  308.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  309. //    MyCaos.M68kStart    =    NULL;
  310. //    MyCaos.M68kSize        =    0;
  311.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  312. //    MyCaos.PPCStart        =    NULL;
  313. //    MyCaos.PPCSize        =    0;
  314.     MyCaos.a0        =(ULONG) localItem;
  315.     MyCaos.caos_Un.Offset    =    (-204);
  316.     MyCaos.a6        =(ULONG) IFFParseBase;    
  317.     PPCCallOS(&MyCaos);
  318. }
  319.  
  320. #define    GoodID(id)    _GoodID(IFFPARSE_BASE_NAME, id)
  321.  
  322. static __inline LONG
  323. _GoodID(void *IFFParseBase, long id)
  324. {
  325. struct Caos    MyCaos;
  326.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  327. //    MyCaos.M68kStart    =    NULL;
  328. //    MyCaos.M68kSize        =    0;
  329.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  330. //    MyCaos.PPCStart        =    NULL;
  331. //    MyCaos.PPCSize        =    0;
  332.     MyCaos.d0        =(ULONG) id;
  333.     MyCaos.caos_Un.Offset    =    (-258);
  334.     MyCaos.a6        =(ULONG) IFFParseBase;    
  335.     return((LONG)PPCCallOS(&MyCaos));
  336. }
  337.  
  338. #define    GoodType(type)    _GoodType(IFFPARSE_BASE_NAME, type)
  339.  
  340. static __inline LONG
  341. _GoodType(void *IFFParseBase, long type)
  342. {
  343. struct Caos    MyCaos;
  344.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  345. //    MyCaos.M68kStart    =    NULL;
  346. //    MyCaos.M68kSize        =    0;
  347.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  348. //    MyCaos.PPCStart        =    NULL;
  349. //    MyCaos.PPCSize        =    0;
  350.     MyCaos.d0        =(ULONG) type;
  351.     MyCaos.caos_Un.Offset    =    (-264);
  352.     MyCaos.a6        =(ULONG) IFFParseBase;    
  353.     return((LONG)PPCCallOS(&MyCaos));
  354. }
  355.  
  356. #define    IDtoStr(id, buf)    _IDtoStr(IFFPARSE_BASE_NAME, id, buf)
  357.  
  358. static __inline STRPTR
  359. _IDtoStr(void *IFFParseBase, long id, STRPTR buf)
  360. {
  361. struct Caos    MyCaos;
  362.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  363. //    MyCaos.M68kStart    =    NULL;
  364. //    MyCaos.M68kSize        =    0;
  365.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  366. //    MyCaos.PPCStart        =    NULL;
  367. //    MyCaos.PPCSize        =    0;
  368.     MyCaos.d0        =(ULONG) id;
  369.     MyCaos.a0        =(ULONG) buf;
  370.     MyCaos.caos_Un.Offset    =    (-270);
  371.     MyCaos.a6        =(ULONG) IFFParseBase;    
  372.     return((STRPTR)PPCCallOS(&MyCaos));
  373. }
  374.  
  375. #define    InitIFF(iff, flags, streamHook)    _InitIFF(IFFPARSE_BASE_NAME, iff, flags, streamHook)
  376.  
  377. static __inline void
  378. _InitIFF(void *IFFParseBase, struct IFFHandle *iff, long flags, struct Hook *streamHook)
  379. {
  380. struct Caos    MyCaos;
  381.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  382. //    MyCaos.M68kStart    =    NULL;
  383. //    MyCaos.M68kSize        =    0;
  384.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  385. //    MyCaos.PPCStart        =    NULL;
  386. //    MyCaos.PPCSize        =    0;
  387.     MyCaos.a0        =(ULONG) iff;
  388.     MyCaos.d0        =(ULONG) flags;
  389.     MyCaos.a1        =(ULONG) streamHook;
  390.     MyCaos.caos_Un.Offset    =    (-228);
  391.     MyCaos.a6        =(ULONG) IFFParseBase;    
  392.     PPCCallOS(&MyCaos);
  393. }
  394.  
  395. #define    InitIFFasClip(iff)    _InitIFFasClip(IFFPARSE_BASE_NAME, iff)
  396.  
  397. static __inline void
  398. _InitIFFasClip(void *IFFParseBase, struct IFFHandle *iff)
  399. {
  400. struct Caos    MyCaos;
  401.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  402. //    MyCaos.M68kStart    =    NULL;
  403. //    MyCaos.M68kSize        =    0;
  404.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  405. //    MyCaos.PPCStart        =    NULL;
  406. //    MyCaos.PPCSize        =    0;
  407.     MyCaos.a0        =(ULONG) iff;
  408.     MyCaos.caos_Un.Offset    =    (-240);
  409.     MyCaos.a6        =(ULONG) IFFParseBase;    
  410.     PPCCallOS(&MyCaos);
  411. }
  412.  
  413. #define    InitIFFasDOS(iff)    _InitIFFasDOS(IFFPARSE_BASE_NAME, iff)
  414.  
  415. static __inline void
  416. _InitIFFasDOS(void *IFFParseBase, struct IFFHandle *iff)
  417. {
  418. struct Caos    MyCaos;
  419.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  420. //    MyCaos.M68kStart    =    NULL;
  421. //    MyCaos.M68kSize        =    0;
  422.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  423. //    MyCaos.PPCStart        =    NULL;
  424. //    MyCaos.PPCSize        =    0;
  425.     MyCaos.a0        =(ULONG) iff;
  426.     MyCaos.caos_Un.Offset    =    (-234);
  427.     MyCaos.a6        =(ULONG) IFFParseBase;    
  428.     PPCCallOS(&MyCaos);
  429. }
  430.  
  431. #define    LocalItemData(localItem)    _LocalItemData(IFFPARSE_BASE_NAME, localItem)
  432.  
  433. static __inline APTR
  434. _LocalItemData(void *IFFParseBase, struct LocalContextItem *localItem)
  435. {
  436. struct Caos    MyCaos;
  437.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  438. //    MyCaos.M68kStart    =    NULL;
  439. //    MyCaos.M68kSize        =    0;
  440.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  441. //    MyCaos.PPCStart        =    NULL;
  442. //    MyCaos.PPCSize        =    0;
  443.     MyCaos.a0        =(ULONG) localItem;
  444.     MyCaos.caos_Un.Offset    =    (-192);
  445.     MyCaos.a6        =(ULONG) IFFParseBase;    
  446.     return((APTR)PPCCallOS(&MyCaos));
  447. }
  448.  
  449. #define    OpenClipboard(unitNumber)    _OpenClipboard(IFFPARSE_BASE_NAME, unitNumber)
  450.  
  451. static __inline struct ClipboardHandle *
  452. _OpenClipboard(void *IFFParseBase, long unitNumber)
  453. {
  454. struct Caos    MyCaos;
  455.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  456. //    MyCaos.M68kStart    =    NULL;
  457. //    MyCaos.M68kSize        =    0;
  458.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  459. //    MyCaos.PPCStart        =    NULL;
  460. //    MyCaos.PPCSize        =    0;
  461.     MyCaos.d0        =(ULONG) unitNumber;
  462.     MyCaos.caos_Un.Offset    =    (-246);
  463.     MyCaos.a6        =(ULONG) IFFParseBase;    
  464.     return((struct ClipboardHandle *)PPCCallOS(&MyCaos));
  465. }
  466.  
  467. #define    OpenIFF(iff, rwMode)    _OpenIFF(IFFPARSE_BASE_NAME, iff, rwMode)
  468.  
  469. static __inline LONG
  470. _OpenIFF(void *IFFParseBase, struct IFFHandle *iff, long rwMode)
  471. {
  472. struct Caos    MyCaos;
  473.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  474. //    MyCaos.M68kStart    =    NULL;
  475. //    MyCaos.M68kSize        =    0;
  476.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  477. //    MyCaos.PPCStart        =    NULL;
  478. //    MyCaos.PPCSize        =    0;
  479.     MyCaos.a0        =(ULONG) iff;
  480.     MyCaos.d0        =(ULONG) rwMode;
  481.     MyCaos.caos_Un.Offset    =    (-36);
  482.     MyCaos.a6        =(ULONG) IFFParseBase;    
  483.     return((LONG)PPCCallOS(&MyCaos));
  484. }
  485.  
  486. #define    ParentChunk(contextNode)    _ParentChunk(IFFPARSE_BASE_NAME, contextNode)
  487.  
  488. static __inline struct ContextNode *
  489. _ParentChunk(void *IFFParseBase, struct ContextNode *contextNode)
  490. {
  491. struct Caos    MyCaos;
  492.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  493. //    MyCaos.M68kStart    =    NULL;
  494. //    MyCaos.M68kSize        =    0;
  495.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  496. //    MyCaos.PPCStart        =    NULL;
  497. //    MyCaos.PPCSize        =    0;
  498.     MyCaos.a0        =(ULONG) contextNode;
  499.     MyCaos.caos_Un.Offset    =    (-180);
  500.     MyCaos.a6        =(ULONG) IFFParseBase;    
  501.     return((struct ContextNode *)PPCCallOS(&MyCaos));
  502. }
  503.  
  504. #define    ParseIFF(iff, control)    _ParseIFF(IFFPARSE_BASE_NAME, iff, control)
  505.  
  506. static __inline LONG
  507. _ParseIFF(void *IFFParseBase, struct IFFHandle *iff, long control)
  508. {
  509. struct Caos    MyCaos;
  510.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  511. //    MyCaos.M68kStart    =    NULL;
  512. //    MyCaos.M68kSize        =    0;
  513.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  514. //    MyCaos.PPCStart        =    NULL;
  515. //    MyCaos.PPCSize        =    0;
  516.     MyCaos.a0        =(ULONG) iff;
  517.     MyCaos.d0        =(ULONG) control;
  518.     MyCaos.caos_Un.Offset    =    (-42);
  519.     MyCaos.a6        =(ULONG) IFFParseBase;    
  520.     return((LONG)PPCCallOS(&MyCaos));
  521. }
  522.  
  523. #define    PopChunk(iff)    _PopChunk(IFFPARSE_BASE_NAME, iff)
  524.  
  525. static __inline LONG
  526. _PopChunk(void *IFFParseBase, struct IFFHandle *iff)
  527. {
  528. struct Caos    MyCaos;
  529.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  530. //    MyCaos.M68kStart    =    NULL;
  531. //    MyCaos.M68kSize        =    0;
  532.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  533. //    MyCaos.PPCStart        =    NULL;
  534. //    MyCaos.PPCSize        =    0;
  535.     MyCaos.a0        =(ULONG) iff;
  536.     MyCaos.caos_Un.Offset    =    (-90);
  537.     MyCaos.a6        =(ULONG) IFFParseBase;    
  538.     return((LONG)PPCCallOS(&MyCaos));
  539. }
  540.  
  541. #define    PropChunk(iff, type, id)    _PropChunk(IFFPARSE_BASE_NAME, iff, type, id)
  542.  
  543. static __inline LONG
  544. _PropChunk(void *IFFParseBase, struct IFFHandle *iff, long type, long id)
  545. {
  546. struct Caos    MyCaos;
  547.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  548. //    MyCaos.M68kStart    =    NULL;
  549. //    MyCaos.M68kSize        =    0;
  550.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  551. //    MyCaos.PPCStart        =    NULL;
  552. //    MyCaos.PPCSize        =    0;
  553.     MyCaos.a0        =(ULONG) iff;
  554.     MyCaos.d0        =(ULONG) type;
  555.     MyCaos.d1        =(ULONG) id;
  556.     MyCaos.caos_Un.Offset    =    (-114);
  557.     MyCaos.a6        =(ULONG) IFFParseBase;    
  558.     return((LONG)PPCCallOS(&MyCaos));
  559. }
  560.  
  561. #define    PropChunks(iff, propArray, numPairs)    _PropChunks(IFFPARSE_BASE_NAME, iff, propArray, numPairs)
  562.  
  563. static __inline LONG
  564. _PropChunks(void *IFFParseBase, struct IFFHandle *iff, LONG *propArray, long numPairs)
  565. {
  566. struct Caos    MyCaos;
  567.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  568. //    MyCaos.M68kStart    =    NULL;
  569. //    MyCaos.M68kSize        =    0;
  570.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  571. //    MyCaos.PPCStart        =    NULL;
  572. //    MyCaos.PPCSize        =    0;
  573.     MyCaos.a0        =(ULONG) iff;
  574.     MyCaos.a1        =(ULONG) propArray;
  575.     MyCaos.d0        =(ULONG) numPairs;
  576.     MyCaos.caos_Un.Offset    =    (-120);
  577.     MyCaos.a6        =(ULONG) IFFParseBase;    
  578.     return((LONG)PPCCallOS(&MyCaos));
  579. }
  580.  
  581. #define    PushChunk(iff, type, id, size)    _PushChunk(IFFPARSE_BASE_NAME, iff, type, id, size)
  582.  
  583. static __inline LONG
  584. _PushChunk(void *IFFParseBase, struct IFFHandle *iff, long type, long id, long size)
  585. {
  586. struct Caos    MyCaos;
  587.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  588. //    MyCaos.M68kStart    =    NULL;
  589. //    MyCaos.M68kSize        =    0;
  590.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  591. //    MyCaos.PPCStart        =    NULL;
  592. //    MyCaos.PPCSize        =    0;
  593.     MyCaos.a0        =(ULONG) iff;
  594.     MyCaos.d0        =(ULONG) type;
  595.     MyCaos.d1        =(ULONG) id;
  596.     MyCaos.d2        =(ULONG) size;
  597.     MyCaos.caos_Un.Offset    =    (-84);
  598.     MyCaos.a6        =(ULONG) IFFParseBase;    
  599.     return((LONG)PPCCallOS(&MyCaos));
  600. }
  601.  
  602. #define    ReadChunkBytes(iff, buf, numBytes)    _ReadChunkBytes(IFFPARSE_BASE_NAME, iff, buf, numBytes)
  603.  
  604. static __inline LONG
  605. _ReadChunkBytes(void *IFFParseBase, struct IFFHandle *iff, APTR buf, long numBytes)
  606. {
  607. struct Caos    MyCaos;
  608.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  609. //    MyCaos.M68kStart    =    NULL;
  610. //    MyCaos.M68kSize        =    0;
  611.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  612. //    MyCaos.PPCStart        =    NULL;
  613. //    MyCaos.PPCSize        =    0;
  614.     MyCaos.a0        =(ULONG) iff;
  615.     MyCaos.a1        =(ULONG) buf;
  616.     MyCaos.d0        =(ULONG) numBytes;
  617.     MyCaos.caos_Un.Offset    =    (-60);
  618.     MyCaos.a6        =(ULONG) IFFParseBase;    
  619.     return((LONG)PPCCallOS(&MyCaos));
  620. }
  621.  
  622. #define    ReadChunkRecords(iff, buf, bytesPerRecord, numRecords)    _ReadChunkRecords(IFFPARSE_BASE_NAME, iff, buf, bytesPerRecord, numRecords)
  623.  
  624. static __inline LONG
  625. _ReadChunkRecords(void *IFFParseBase, struct IFFHandle *iff, APTR buf, long bytesPerRecord, long numRecords)
  626. {
  627. struct Caos    MyCaos;
  628.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  629. //    MyCaos.M68kStart    =    NULL;
  630. //    MyCaos.M68kSize        =    0;
  631.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  632. //    MyCaos.PPCStart        =    NULL;
  633. //    MyCaos.PPCSize        =    0;
  634.     MyCaos.a0        =(ULONG) iff;
  635.     MyCaos.a1        =(ULONG) buf;
  636.     MyCaos.d0        =(ULONG) bytesPerRecord;
  637.     MyCaos.d1        =(ULONG) numRecords;
  638.     MyCaos.caos_Un.Offset    =    (-72);
  639.     MyCaos.a6        =(ULONG) IFFParseBase;    
  640.     return((LONG)PPCCallOS(&MyCaos));
  641. }
  642.  
  643. #define    SetLocalItemPurge(localItem, purgeHook)    _SetLocalItemPurge(IFFPARSE_BASE_NAME, localItem, purgeHook)
  644.  
  645. static __inline void
  646. _SetLocalItemPurge(void *IFFParseBase, struct LocalContextItem *localItem, struct Hook *purgeHook)
  647. {
  648. struct Caos    MyCaos;
  649.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  650. //    MyCaos.M68kStart    =    NULL;
  651. //    MyCaos.M68kSize        =    0;
  652.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  653. //    MyCaos.PPCStart        =    NULL;
  654. //    MyCaos.PPCSize        =    0;
  655.     MyCaos.a0        =(ULONG) localItem;
  656.     MyCaos.a1        =(ULONG) purgeHook;
  657.     MyCaos.caos_Un.Offset    =    (-198);
  658.     MyCaos.a6        =(ULONG) IFFParseBase;    
  659.     PPCCallOS(&MyCaos);
  660. }
  661.  
  662. #define    StopChunk(iff, type, id)    _StopChunk(IFFPARSE_BASE_NAME, iff, type, id)
  663.  
  664. static __inline LONG
  665. _StopChunk(void *IFFParseBase, struct IFFHandle *iff, long type, long id)
  666. {
  667. struct Caos    MyCaos;
  668.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  669. //    MyCaos.M68kStart    =    NULL;
  670. //    MyCaos.M68kSize        =    0;
  671.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  672. //    MyCaos.PPCStart        =    NULL;
  673. //    MyCaos.PPCSize        =    0;
  674.     MyCaos.a0        =(ULONG) iff;
  675.     MyCaos.d0        =(ULONG) type;
  676.     MyCaos.d1        =(ULONG) id;
  677.     MyCaos.caos_Un.Offset    =    (-126);
  678.     MyCaos.a6        =(ULONG) IFFParseBase;    
  679.     return((LONG)PPCCallOS(&MyCaos));
  680. }
  681.  
  682. #define    StopChunks(iff, propArray, numPairs)    _StopChunks(IFFPARSE_BASE_NAME, iff, propArray, numPairs)
  683.  
  684. static __inline LONG
  685. _StopChunks(void *IFFParseBase, struct IFFHandle *iff, LONG *propArray, long numPairs)
  686. {
  687. struct Caos    MyCaos;
  688.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  689. //    MyCaos.M68kStart    =    NULL;
  690. //    MyCaos.M68kSize        =    0;
  691.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  692. //    MyCaos.PPCStart        =    NULL;
  693. //    MyCaos.PPCSize        =    0;
  694.     MyCaos.a0        =(ULONG) iff;
  695.     MyCaos.a1        =(ULONG) propArray;
  696.     MyCaos.d0        =(ULONG) numPairs;
  697.     MyCaos.caos_Un.Offset    =    (-132);
  698.     MyCaos.a6        =(ULONG) IFFParseBase;    
  699.     return((LONG)PPCCallOS(&MyCaos));
  700. }
  701.  
  702. #define    StopOnExit(iff, type, id)    _StopOnExit(IFFPARSE_BASE_NAME, iff, type, id)
  703.  
  704. static __inline LONG
  705. _StopOnExit(void *IFFParseBase, struct IFFHandle *iff, long type, long id)
  706. {
  707. struct Caos    MyCaos;
  708.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  709. //    MyCaos.M68kStart    =    NULL;
  710. //    MyCaos.M68kSize        =    0;
  711.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  712. //    MyCaos.PPCStart        =    NULL;
  713. //    MyCaos.PPCSize        =    0;
  714.     MyCaos.a0        =(ULONG) iff;
  715.     MyCaos.d0        =(ULONG) type;
  716.     MyCaos.d1        =(ULONG) id;
  717.     MyCaos.caos_Un.Offset    =    (-150);
  718.     MyCaos.a6        =(ULONG) IFFParseBase;    
  719.     return((LONG)PPCCallOS(&MyCaos));
  720. }
  721.  
  722. #define    StoreItemInContext(iff, localItem, contextNode)    _StoreItemInContext(IFFPARSE_BASE_NAME, iff, localItem, contextNode)
  723.  
  724. static __inline void
  725. _StoreItemInContext(void *IFFParseBase, struct IFFHandle *iff, struct LocalContextItem *localItem, struct ContextNode *contextNode)
  726. {
  727. struct Caos    MyCaos;
  728.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  729. //    MyCaos.M68kStart    =    NULL;
  730. //    MyCaos.M68kSize        =    0;
  731.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  732. //    MyCaos.PPCStart        =    NULL;
  733. //    MyCaos.PPCSize        =    0;
  734.     MyCaos.a0        =(ULONG) iff;
  735.     MyCaos.a1        =(ULONG) localItem;
  736.     MyCaos.a2        =(ULONG) contextNode;
  737.     MyCaos.caos_Un.Offset    =    (-222);
  738.     MyCaos.a6        =(ULONG) IFFParseBase;    
  739.     PPCCallOS(&MyCaos);
  740. }
  741.  
  742. #define    StoreLocalItem(iff, localItem, position)    _StoreLocalItem(IFFPARSE_BASE_NAME, iff, localItem, position)
  743.  
  744. static __inline LONG
  745. _StoreLocalItem(void *IFFParseBase, struct IFFHandle *iff, struct LocalContextItem *localItem, long position)
  746. {
  747. struct Caos    MyCaos;
  748.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  749. //    MyCaos.M68kStart    =    NULL;
  750. //    MyCaos.M68kSize        =    0;
  751.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  752. //    MyCaos.PPCStart        =    NULL;
  753. //    MyCaos.PPCSize        =    0;
  754.     MyCaos.a0        =(ULONG) iff;
  755.     MyCaos.a1        =(ULONG) localItem;
  756.     MyCaos.d0        =(ULONG) position;
  757.     MyCaos.caos_Un.Offset    =    (-216);
  758.     MyCaos.a6        =(ULONG) IFFParseBase;    
  759.     return((LONG)PPCCallOS(&MyCaos));
  760. }
  761.  
  762. #define    WriteChunkBytes(iff, buf, numBytes)    _WriteChunkBytes(IFFPARSE_BASE_NAME, iff, buf, numBytes)
  763.  
  764. static __inline LONG
  765. _WriteChunkBytes(void *IFFParseBase, struct IFFHandle *iff, APTR buf, long numBytes)
  766. {
  767. struct Caos    MyCaos;
  768.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  769. //    MyCaos.M68kStart    =    NULL;
  770. //    MyCaos.M68kSize        =    0;
  771.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  772. //    MyCaos.PPCStart        =    NULL;
  773. //    MyCaos.PPCSize        =    0;
  774.     MyCaos.a0        =(ULONG) iff;
  775.     MyCaos.a1        =(ULONG) buf;
  776.     MyCaos.d0        =(ULONG) numBytes;
  777.     MyCaos.caos_Un.Offset    =    (-66);
  778.     MyCaos.a6        =(ULONG) IFFParseBase;    
  779.     return((LONG)PPCCallOS(&MyCaos));
  780. }
  781.  
  782. #define    WriteChunkRecords(iff, buf, bytesPerRecord, numRecords)    _WriteChunkRecords(IFFPARSE_BASE_NAME, iff, buf, bytesPerRecord, numRecords)
  783.  
  784. static __inline LONG
  785. _WriteChunkRecords(void *IFFParseBase, struct IFFHandle *iff, APTR buf, long bytesPerRecord, long numRecords)
  786. {
  787. struct Caos    MyCaos;
  788.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  789. //    MyCaos.M68kStart    =    NULL;
  790. //    MyCaos.M68kSize        =    0;
  791.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  792. //    MyCaos.PPCStart        =    NULL;
  793. //    MyCaos.PPCSize        =    0;
  794.     MyCaos.a0        =(ULONG) iff;
  795.     MyCaos.a1        =(ULONG) buf;
  796.     MyCaos.d0        =(ULONG) bytesPerRecord;
  797.     MyCaos.d1        =(ULONG) numRecords;
  798.     MyCaos.caos_Un.Offset    =    (-78);
  799.     MyCaos.a6        =(ULONG) IFFParseBase;    
  800.     return((LONG)PPCCallOS(&MyCaos));
  801. }
  802.  
  803. #endif /* SASC Pragmas */
  804. #endif /* !_PPCPRAGMA_IFFPARSE_H */
  805.